home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / magazi~1 / 334 / box.c next >
Encoding:
C/C++ Source or Header  |  1988-11-04  |  9.1 KB  |  327 lines
  1. /********************************************************/
  2. /*                C-manship, Listing 1                  */
  3. /*                     ST-Log #25                       */
  4. /*              Developed with Megamax C                */
  5. /********************************************************/
  6. #include <obdefs.h>
  7. #include <gemdefs.h>
  8.  
  9. #define TRUE    1
  10. #define FALSE   0
  11. #define SOLID   1
  12. #define PATTERN 2
  13. #define LEFT    1
  14. #define RIGHT   2
  15.  
  16. /* GEM arrays */
  17. int work_in[11], work_out[57], contrl[12], intin[128], 
  18.     ptsin[128], intout[128], ptsout[128];
  19.  
  20. int handle,    /* Application handle. */
  21.     dum;       /* Dummy storage.      */
  22.  
  23.  
  24. /******************************************************
  25. * Main program.
  26. ******************************************************/
  27. main ()
  28. {
  29.    appl_init ();           /* Init application.         */
  30.    open_vwork ();          /* Open virtual workstation. */
  31.    do_box ();              /* Go do our thing.          */
  32.    v_clsvwk ( handle );    /* Close virtual workstation.*/
  33.    appl_exit ();           /* Back to the desktop.      */
  34. }
  35.  
  36.  
  37. /******************************************************
  38. * do_box ()
  39. * 
  40. * Calls screen setup function and handles the mouse,
  41. * calling the appropriate box functions based on the
  42. * mouse's coordinates and button state.
  43. ******************************************************/
  44. do_box ()
  45. {
  46.    int mouse_x,    /* Mouse X coordinate.     */
  47.        mouse_y,    /* Mouse Y coordinate.     */
  48.        mouse_but,  /* Mouse button state.     */
  49.        box_x,      /* Selected box X coord.   */
  50.        box_y,      /* Selected box Y coord.   */
  51.        box_width,  /* Selected width of box.  */
  52.        box_height, /* Selected height of box. */ 
  53.        exit,       /* Program exit flag.      */
  54.        coords_ok;  /* Proper coordinates flag.*/
  55.  
  56.    setup_scrn ();
  57.    coords_ok = FALSE;
  58.    graf_mouse ( ARROW, 0L );
  59.  
  60.    /* Wait for box coordinates within the boundary. */
  61.    while ( !coords_ok ) {
  62.  
  63.       /* Poll for left button press. */
  64.       mouse_but = 0;
  65.       while ( mouse_but != LEFT )
  66.          graf_mkstate ( &mouse_x, &mouse_y, &mouse_but, &dum );
  67.  
  68.       /* Get coordinates for the box. */
  69.       box_x = mouse_x;
  70.       box_y = mouse_y;
  71.       graf_rubberbox ( box_x, box_y, 20, 20, &box_width, &box_height );
  72.  
  73.       /* Allow only a box whose size fits within the */
  74.       /* boundary to be drawn.                       */
  75.       if ( box_x > 20 && box_x + box_width < work_out[0]-21 &&
  76.            box_y > 20 && box_y + box_height < work_out[1]-21 ) {
  77.          draw_box ( box_x, box_y, box_width, box_height );
  78.          coords_ok = TRUE;
  79.       }
  80.    }
  81.    exit = FALSE;
  82.    while ( !exit ) {
  83.       mouse_but = 0;
  84.  
  85.       /* Wait for press of left or right mouse button. */
  86.       while ( mouse_but != LEFT && mouse_but != RIGHT )
  87.          graf_mkstate ( &mouse_x, &mouse_y, &mouse_but, &dum );
  88.  
  89.       if ( mouse_but == LEFT )
  90.  
  91.          /* If the mouse was on the sizing button, */
  92.          /* allow the user to resize the box.      */
  93.          if ( chose_size ( mouse_x, mouse_y, box_x, box_y, 
  94.                            box_width, box_height ) )
  95.             size_box ( box_x, box_y, &box_width, &box_height );
  96.  
  97.          /* If the mouse was anywhere else in the */
  98.          /* box, allow the user to move the box.  */
  99.          else if ( chose_move ( mouse_x, mouse_y, box_x, box_y, 
  100.                                   box_width, box_height ) )
  101.             move_box ( &box_x, &box_y, box_width, box_height );
  102.  
  103.       if ( mouse_but == RIGHT )
  104.          exit = TRUE;
  105.    }
  106. }
  107.  
  108.  
  109. /******************************************************
  110. * draw_box ()
  111. * 
  112. * Draws a shaded box with a button in the lower right
  113. * corner.  The input is the X and Y coordinates of
  114. * the box's upper left corner and its width and height.
  115. ******************************************************/
  116. draw_box ( x, y, w, h )
  117. int x, y, w, h;
  118. {
  119.    int pxy[4];
  120.  
  121.    graf_mouse ( M_OFF, 0L );
  122.  
  123.    /* Draw the main body of the box. */
  124.    vsf_interior ( handle, PATTERN );
  125.    vsf_style ( handle, 5 );
  126.    vsf_color ( handle, BLACK );
  127.    pxy[0] = x;
  128.    pxy[1] = y;
  129.    pxy[2] = x + w - 1;
  130.    pxy[3] = y + h - 1;
  131.    v_bar ( handle, pxy );
  132.  
  133.    /* Draw the box's sizing button. */
  134.    vsf_interior ( handle, SOLID );
  135.    pxy[0] = x + w - 10;
  136.    pxy[1] = y + h - 10;
  137.    v_bar ( handle, pxy );
  138.  
  139.    graf_mouse ( M_ON, 0L ); 
  140. }
  141.  
  142.  
  143. /******************************************************
  144. * size_box ()
  145. * 
  146. * Resizes a box.  The input is the X and Y coordinates
  147. * of the box and pointers to its width and height.  The
  148. * function returns the new width and height by way
  149. * of the pointers, thus replacing the old values of 
  150. * the width and height.
  151. ******************************************************/
  152. size_box ( x, y, w, h )
  153. int x, y, *w, *h;
  154. {
  155.    int old_w, old_h;
  156.    int pxy[4];
  157.  
  158.    old_w = *w;
  159.    old_h = *h;
  160.  
  161.    /* Get the new box size. */
  162.    graf_rubberbox ( x, y, 20, 20, w, h );
  163.  
  164.    /* Don't allow the new box to exceed the boundary. */
  165.    if ( x + *w > work_out[0]-20 | y + *h > work_out[1]-20 ) {
  166.       *w = old_w;
  167.       *h = old_h;
  168.    }
  169.  
  170.    /* If the size is okay, draw the box. */
  171.    else {
  172.       draw_box ( x, y, *w, *h );
  173.  
  174.       /* Erase the leftover portions (if */
  175.       /* any) of the old box.            */
  176.       graf_mouse ( M_OFF, 0L );
  177.       vsf_interior ( handle, SOLID );
  178.       vsf_color ( handle, WHITE );
  179.       if ( *w < old_w ) {
  180.          pxy[0] = x + *w;
  181.          pxy[1] = y;
  182.          pxy[2] = x + old_w - 1;
  183.          pxy[3] = y + old_h - 1;
  184.          v_bar ( handle, pxy );
  185.       }
  186.       if ( *h < old_h ) {
  187.          pxy[0] = x;
  188.          pxy[1] = y + *h;
  189.          pxy[2] = x + old_w - 1;
  190.          pxy[3] = y + old_h - 1;
  191.          v_bar ( handle, pxy );
  192.       }
  193.       graf_mouse ( M_ON, 0L );
  194.    }
  195. }
  196.  
  197.  
  198. /******************************************************
  199. * move_box ()
  200. * 
  201. * Repositions a box.  The input is a pointer to the
  202. * box's X coord., a pointer to the box's Y coord., and 
  203. * the box's width and height.  The new X and Y 
  204. * coordinates are returned from the function by way of 
  205. * the pointers, thus replacing the old X and Y values.
  206. ******************************************************/
  207. move_box ( x, y, w, h )
  208. int *x, *y, w, h;
  209. {
  210.    int old_x, old_y;
  211.    int pxy[4];
  212.  
  213.    old_x = *x;
  214.    old_y = *y;
  215.    graf_mouse ( FLAT_HAND, 0L );
  216.  
  217.    /* Get new location for the box. */
  218.    graf_dragbox ( w, h, *x, *y, 21, 21, 
  219.                   work_out[0]-41, work_out[1]-41, x, y );
  220.  
  221.    /* Erase the old box. */
  222.    graf_mouse ( M_OFF, 0L );
  223.    vsf_color ( handle, WHITE );
  224.    vsf_interior ( handle, SOLID );
  225.    pxy[0] = old_x;
  226.    pxy[1] = old_y;
  227.    pxy[2] = old_x + w - 1;
  228.    pxy[3] = old_y + h - 1;
  229.    v_bar ( handle, pxy );
  230.  
  231.    /* Draw the new box. */
  232.    draw_box ( *x, *y, w, h );
  233.  
  234.    graf_mouse ( M_ON, 0L );
  235.    graf_mouse ( ARROW, 0L );
  236. }
  237.  
  238.  
  239. /******************************************************
  240. * chose_size ()
  241. * 
  242. * Returns a boolean value based on whether the mouse
  243. * button was pressed while over the box's sizing
  244. * button.  The input is the X and Y coordinates of
  245. * the mouse, the X and Y coordinates of the box, and
  246. * the width and height of the box.
  247. ******************************************************/
  248. chose_size ( mx, my, bx, by, bw, bh )
  249. int mx, my, bx, by, bw, bh;
  250. {
  251.    if ( mx>bx+bw-10 && mx<bx+bw && my>by+bh-10 && my<by+bh )
  252.       return ( TRUE );
  253.    else
  254.       return ( FALSE );
  255. }
  256.  
  257.  
  258. /******************************************************
  259. * chose_move ()
  260. * 
  261. * Returns a boolean value based on whether the mouse
  262. * button was pressed while over an area of the box
  263. * other than the sizing button.  The input is the X 
  264. * and Y coordinates of the mouse, the X and Y 
  265. * coordinates of the box, and the width and height of 
  266. * the box.
  267. ******************************************************/
  268. chose_move ( mx, my, bx, by, bw, bh )
  269. int mx, my, bx, by, bw, bh;
  270. {
  271.    if ( mx>bx && mx<bx+bw && my>by && my<by+bh )
  272.       return ( TRUE );
  273.    else
  274.       return ( FALSE );
  275. }
  276.  
  277.  
  278. /******************************************************
  279. * setup_scrn ()
  280. * 
  281. * Prepares the screen by clearing the workstation and
  282. * drawing a border.
  283. ******************************************************/
  284. setup_scrn ()
  285. {
  286.    int pxy[10];
  287.  
  288.    graf_mouse ( M_OFF, 0L );
  289.  
  290.    /* Erase the screen. */
  291.    v_clrwk ( handle );
  292.  
  293.    /* Draw the border. */
  294.    pxy[0] = 20;
  295.    pxy[1] = 20;
  296.    pxy[2] = work_out[0] - 20;
  297.    pxy[3] = 20;
  298.    pxy[4] = work_out[0] - 20;
  299.    pxy[5] = work_out[1] - 20;
  300.    pxy[6] = 20;
  301.    pxy[7] = work_out[1] - 20;
  302.    pxy[8] = 20;
  303.    pxy[9] = 20;
  304.    v_pline ( handle, 5, pxy );
  305.  
  306.    graf_mouse ( M_ON, 0L );
  307. }
  308.  
  309.  
  310. /*****************************************************
  311. * open_vwork ()
  312. * Opens a virtual workstation.
  313. *****************************************************/
  314. open_vwork ()
  315. {
  316.    int i;
  317.  
  318.    /* Get graphics handle, initialize the GEM arrays and open  */
  319.    /* a virtual workstation.                                   */
  320.  
  321.    handle = graf_handle ( &dum, &dum, &dum, &dum);
  322.    for ( i=0; i<10; work_in[i++] = 1 );
  323.    work_in[10] = 2;
  324.    v_opnvwk ( work_in, &handle, work_out );
  325. }
  326.  
  327.